FEXPMultiGraph.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Graph algorithms.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPMULTIGRAPH_H_
#define _CFEXPMULTIGRAPH_H_
#include "FEXPCommon.h"

// primary template
template<typename TValue, typename Enable = void>
class CFEXPMultiGraph { };
template<typename TValue>
class CFEXPMultiGraph
  <TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
{
public:
  CFEXPMultiGraph();
  virtual ~CFEXPMultiGraph();

  // add edge to graph
  void AddEdge(TValue vert1, TValue vert2);
  // gives map of graphs and their nodes
  Ptr<std::map<size_t, std::vector<TValue>>> GetGraphs();
  // number of already added vertexes
  size_t GetEdgeCount() const { return _edge_counter; }
protected:
  // [no protected members] -----------------------------
private:
  size_t _edge_counter;
  struct vertex
  {
    TValue               _ID;
    bool                 _CLR;
    std::vector<vertex*> _ADJ;
    vertex(TValue id) : _ID(id), _CLR(false) { }
  };
  std::map<TValue, Ptr<vertex>> _graph_vertx_map;
  // deep-first search algorithm (DFS)
  void dfs_recurse(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number);
  void dfs_not_rcs(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number);
  bool try_clr_vtx(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number);
};

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>::CFEXPMultiGraph()
  : _edge_counter(FEXPCOMMON_DEFAULT_VALUE) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>::~CFEXPMultiGraph() { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
  ::AddEdge(TValue vrtx1, TValue vrtx2)
//--------------------------------------------------------------------------------------
{
  // vertex -- 1
  auto vertex1 = Ptr<vertex>();
  if (!_graph_vertx_map.count(vrtx1))
  {
    vertex1 = CFEXPDataManager<vertex>::SafeAllocInstance(vrtx1);
    _graph_vertx_map.insert(MAP_PAIR(vertex1->_ID, vertex1));
  }
  else
    vertex1 = _graph_vertx_map[vrtx1];
  // vertex -- 2
  auto vertex2 = Ptr<vertex>();
  if (!_graph_vertx_map.count(vrtx2))
  {
    vertex2 = CFEXPDataManager<vertex>::SafeAllocInstance(vrtx2);
    _graph_vertx_map.insert(MAP_PAIR(vertex2->_ID, vertex2));
  }
  else
    vertex2 = _graph_vertx_map[vrtx2];
  // create edge
  vertex1->_ADJ.push_back(vertex2.get());
  vertex2->_ADJ.push_back(vertex1.get());
  ++_edge_counter;
}

//--------------------------------------------------------------------------------------
template<typename TValue>
Ptr<std::map<size_t, std::vector<TValue>>>
CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
  ::GetGraphs()
//--------------------------------------------------------------------------------------
{
  // check if graph is empty
  auto result = Ptr<std::map<size_t, std::vector<TValue>>>();
  if (_graph_vertx_map.empty())
    return result;
  // allocate result
  result = CFEXPDataManager<std::map<size_t, std::vector<TValue>>>::SafeAllocInstance();
  // create map of graphs and their vertexes
  size_t graph_number_generator = 0;
  FEXPCOMMON_FOREACH_ITER_FNC(_graph_vertx_map, { dfs_not_rcs(IT.second.get(), result, ++graph_number_generator); });
  // mark all vertexes as not processed (for repeated use of this function for search)
  FEXPCOMMON_FOREACH_ITER_FNC(_graph_vertx_map, { IT.second->_CLR = false; });
  return result;
}

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
  ::dfs_recurse(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number)
//--------------------------------------------------------------------------------------
{
  // check if vertex has been already processed
  if (!try_clr_vtx(vert, res_map, g_number))
    return;
  // process new adjacency vertexes
  FEXPCOMMON_FOREACH_ITER_FNC(vert->_ADJ, { dfs_recurse(IT, res_map, g_number); });
}

//--------------------------------------------------------------------------------------
template<typename TValue>
void CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
  ::dfs_not_rcs(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number)
//--------------------------------------------------------------------------------------
{
  std::stack<vertex*> vertex_stack;
  vertex_stack.push(vert);
  while (!vertex_stack.empty())
  {
    auto current_vert = vertex_stack.top();
    vertex_stack.pop();
    // check if vertex has already been processed
    if (!try_clr_vtx(current_vert, res_map, g_number))
      continue;
    // process new adjacency vertexes
    FEXPCOMMON_FOREACH_ITER_FNC(current_vert->_ADJ, { vertex_stack.push(IT); });
  }
}

//--------------------------------------------------------------------------------------
template<typename TValue>
bool CFEXPMultiGraph<TValue, typename std::enable_if_t<std::is_integral<TValue>::value>>
  ::try_clr_vtx(vertex * vert, Ptr<std::map<size_t, std::vector<TValue>>> res_map, size_t g_number)
//--------------------------------------------------------------------------------------
{
  // check if vertex has been processed
  if (vert->_CLR)
    return false;
  // check if graph is presented in map,
  // if not so add it to result
  if (!res_map->count(g_number))
    res_map->insert(MAP_PAIR(g_number, std::vector<TValue>()));
  res_map->at(g_number).push_back(vert->_ID);
  // mark vertex as processed
  vert->_CLR = true;
  return true;
}

#endif // !_CFEXPMULTIGRAPH_H_